home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / smp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  4.7 KB  |  185 lines
  1. #ifndef __LINUX_SMP_H
  2. #define __LINUX_SMP_H
  3.  
  4. /*
  5.  *    Generic SMP support
  6.  *        Alan Cox. <alan@redhat.com>
  7.  */
  8.  
  9. #include <linux/errno.h>
  10. #include <linux/types.h>
  11. #include <linux/list.h>
  12. #include <linux/cpumask.h>
  13.  
  14. extern void cpu_idle(void);
  15.  
  16. struct call_single_data {
  17.     struct list_head list;
  18.     void (*func) (void *info);
  19.     void *info;
  20.     u16 flags;
  21.     u16 priv;
  22. };
  23.  
  24. #ifdef CONFIG_SMP
  25.  
  26. #include <linux/preempt.h>
  27. #include <linux/kernel.h>
  28. #include <linux/compiler.h>
  29. #include <linux/thread_info.h>
  30. #include <asm/smp.h>
  31.  
  32. /*
  33.  * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
  34.  * (defined in asm header):
  35.  */ 
  36.  
  37. /*
  38.  * stops all CPUs but the current one:
  39.  */
  40. extern void smp_send_stop(void);
  41.  
  42. /*
  43.  * sends a 'reschedule' event to another CPU:
  44.  */
  45. extern void smp_send_reschedule(int cpu);
  46.  
  47.  
  48. /*
  49.  * Prepare machine for booting other CPUs.
  50.  */
  51. extern void smp_prepare_cpus(unsigned int max_cpus);
  52.  
  53. /*
  54.  * Bring a CPU up
  55.  */
  56. extern int __cpu_up(unsigned int cpunum);
  57.  
  58. /*
  59.  * Final polishing of CPUs
  60.  */
  61. extern void smp_cpus_done(unsigned int max_cpus);
  62.  
  63. /*
  64.  * Call a function on all other processors
  65.  */
  66. int smp_call_function(void(*func)(void *info), void *info, int wait);
  67. /* Deprecated: use smp_call_function_many() which uses a cpumask ptr. */
  68. int smp_call_function_mask(cpumask_t mask, void(*func)(void *info), void *info,
  69.                 int wait);
  70.  
  71. static inline void smp_call_function_many(const struct cpumask *mask,
  72.                       void (*func)(void *info), void *info,
  73.                       int wait)
  74. {
  75.     smp_call_function_mask(*mask, func, info, wait);
  76. }
  77.  
  78. int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
  79.                 int wait);
  80. void __smp_call_function_single(int cpuid, struct call_single_data *data);
  81.  
  82. /*
  83.  * Generic and arch helpers
  84.  */
  85. #ifdef CONFIG_USE_GENERIC_SMP_HELPERS
  86. void generic_smp_call_function_single_interrupt(void);
  87. void generic_smp_call_function_interrupt(void);
  88. void ipi_call_lock(void);
  89. void ipi_call_unlock(void);
  90. void ipi_call_lock_irq(void);
  91. void ipi_call_unlock_irq(void);
  92. #endif
  93.  
  94. /*
  95.  * Call a function on all processors
  96.  */
  97. int on_each_cpu(void (*func) (void *info), void *info, int wait);
  98.  
  99. #define MSG_ALL_BUT_SELF    0x8000    /* Assume <32768 CPU's */
  100. #define MSG_ALL            0x8001
  101.  
  102. #define MSG_INVALIDATE_TLB    0x0001    /* Remote processor TLB invalidate */
  103. #define MSG_STOP_CPU        0x0002    /* Sent to shut down slave CPU's
  104.                      * when rebooting
  105.                      */
  106. #define MSG_RESCHEDULE        0x0003    /* Reschedule request from master CPU*/
  107. #define MSG_CALL_FUNCTION       0x0004  /* Call function on all other CPUs */
  108.  
  109. /*
  110.  * Mark the boot cpu "online" so that it can call console drivers in
  111.  * printk() and can access its per-cpu storage.
  112.  */
  113. void smp_prepare_boot_cpu(void);
  114.  
  115. extern unsigned int setup_max_cpus;
  116.  
  117. #else /* !SMP */
  118.  
  119. /*
  120.  *    These macros fold the SMP functionality into a single CPU system
  121.  */
  122. #define raw_smp_processor_id()            0
  123. static inline int up_smp_call_function(void (*func)(void *), void *info)
  124. {
  125.     return 0;
  126. }
  127. #define smp_call_function(func, info, wait) \
  128.             (up_smp_call_function(func, info))
  129. #define on_each_cpu(func,info,wait)        \
  130.     ({                    \
  131.         local_irq_disable();        \
  132.         func(info);            \
  133.         local_irq_enable();        \
  134.         0;                \
  135.     })
  136. static inline void smp_send_reschedule(int cpu) { }
  137. #define num_booting_cpus()            1
  138. #define smp_prepare_boot_cpu()            do {} while (0)
  139. #define smp_call_function_single(cpuid, func, info, wait) \
  140. ({ \
  141.     WARN_ON(cpuid != 0);    \
  142.     local_irq_disable();    \
  143.     (func)(info);        \
  144.     local_irq_enable();    \
  145.     0;            \
  146. })
  147. #define smp_call_function_mask(mask, func, info, wait) \
  148.             (up_smp_call_function(func, info))
  149. #define smp_call_function_many(mask, func, info, wait) \
  150.             (up_smp_call_function(func, info))
  151. static inline void init_call_single_data(void)
  152. {
  153. }
  154. #endif /* !SMP */
  155.  
  156. /*
  157.  * smp_processor_id(): get the current CPU ID.
  158.  *
  159.  * if DEBUG_PREEMPT is enabled the we check whether it is
  160.  * used in a preemption-safe way. (smp_processor_id() is safe
  161.  * if it's used in a preemption-off critical section, or in
  162.  * a thread that is bound to the current CPU.)
  163.  *
  164.  * NOTE: raw_smp_processor_id() is for internal use only
  165.  * (smp_processor_id() is the preferred variant), but in rare
  166.  * instances it might also be used to turn off false positives
  167.  * (i.e. smp_processor_id() use that the debugging code reports but
  168.  * which use for some reason is legal). Don't use this to hack around
  169.  * the warning message, as your code might not work under PREEMPT.
  170.  */
  171. #ifdef CONFIG_DEBUG_PREEMPT
  172.   extern unsigned int debug_smp_processor_id(void);
  173. # define smp_processor_id() debug_smp_processor_id()
  174. #else
  175. # define smp_processor_id() raw_smp_processor_id()
  176. #endif
  177.  
  178. #define get_cpu()        ({ preempt_disable(); smp_processor_id(); })
  179. #define put_cpu()        preempt_enable()
  180. #define put_cpu_no_resched()    preempt_enable_no_resched()
  181.  
  182. void smp_setup_processor_id(void);
  183.  
  184. #endif /* __LINUX_SMP_H */
  185.